import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

/**
 * Classe qui permet de creer un escargot, un element primordial dans le jeu !
 *
 */
public class Escargot extends Animal {
        
    private BufferedImage img;
    protected int poids;
    protected float etatFaim;
    protected int prixAchatEscargot;  
	private Environnement environnement;
	private int pointsDeVie=200;

    private int facteurDeplacement=4;

    private BoutiqueAchatSalade boutiqueAchatSalade; 
    private boolean modeAuto;
	private int emplacementEscargot;
	private int imageEscargot;

 
/**
 * Constructeur escargot permet sa création
 * 
 * @param positionEscargotX	
 * 			position de l'escargot sur l'axe des X (int)
 * @param positionEscargotY
 * 			position de l'escargot sur l'axe des Y (int)
 * @param nomEscargot
 * 			nom de l'escargot g�n�r� al�atoirement (String)
 * @param etatFaim
 * 			jauge de faim (int)
 * @param prixAchatEscargot
 * 			prix de l'escargot � l'achat (int)
 * @param poidsEscargot
 * 			poids de l'escargot (int)
 * @param _environnement
 * 			environnement dans lequel �volue l'escargot (Environnement)
 */

    public Escargot(int positionEscargotX, int positionEscargotY, String nomEscargot,
                int etatFaim, int prixAchatEscargot, int poidsEscargot,int imageEscargot, Environnement _environnement) {
        
                super(positionEscargotX, positionEscargotY, nomEscargot, _environnement);
                this.setPoids(poidsEscargot);
                this.etatFaim = etatFaim;
                this.prixAchatEscargot = prixAchatEscargot;
                this.imageEscargot = imageEscargot;
                this.environnement = _environnement;
                this.modeAuto=true;
        }


/**
 * Si l'escargot detecter de la salade pres de lui et qu'il a faim alors il la mange
 */
    public void nourrirEscargot() {
    	
    	for (int i = 0; i <= (environnement.getModele().getListeEscargot().size())-1; i++){
    		if (this.verifierPresenceNouriturre()==true & environnement.getModele().getListeEscargot().elementAt(i).getEtatFaim()<=90){
    			this.modeAuto=false;    			
    		}
    		else {
    			modeAuto=true;
    		}
    	}
    }
    
/**
 * Dessin de l'escargot       
 * @param g
 */
	public void affichage(Graphics g) {
		try {
			if(imageEscargot==1){
        	img = ImageIO.read(new File("img/escargot.png"));
        	}
			if(imageEscargot==2){
	        	img = ImageIO.read(new File("img/escargot1.png"));
	        	}
			if(imageEscargot==3){
	        	img = ImageIO.read(new File("img/escargot2.png"));
	        	}
        } catch (IOException e) {
                        e.printStackTrace();
        }
            g.drawImage(img,this.getPositionAnimalX(),this.getPositionAnimalY(),null);
		
	}

/**
  * Verifie la presence d'une salade en jeu
  * 
  * @return true si une salade est en jeu, false sinon
  */
    public boolean verifierPresenceNouriturre() {
        if (environnement.getModele().getListeSalade().size()!=0){ 
                return true;}
        else    	return false;
    }
    
    /**
     * Permet le deplacement d'un escargot suvant deux modes:
     * auto : il n'y a pas de salade dans notre environnement et qu'il n'est pas l'escargot le plus affamé, l'escargot se deplace librement
     * non auto : il y a une salade dans notre environnement et il est l'escargot le plus affamé, l'escargot se deplace vers la salade
     */
    public void deplacerEscargot() {
    	collision(this, this.contourCollision());
    	
    	Escargot escargotAffame = this.trouverEscargotAffame();
    	
       	if(this!=escargotAffame | (this==escargotAffame && modeAuto==true )){
    			 if(this.get_goX()==true) { 
    				 this.setPositionAnimalX(this.getPositionAnimalX()+facteurDeplacement); 
    			 }
    			 
    			 else {
    				 this.setPositionAnimalX(this.getPositionAnimalX()-facteurDeplacement);
    			 }
    			 
    			 if(this.get_goY()==true) {
    				 this.setPositionAnimalY(this.getPositionAnimalY()+facteurDeplacement);
    			 }
    			 
    			 else {
    				 this.setPositionAnimalY(this.getPositionAnimalY()-facteurDeplacement);
    			 }
    			 
       	}
    	
    	if(modeAuto==false & this==escargotAffame){
    		if (environnement.getModele().getListeSalade().size()!=0) {
    		Salade saladeSelectionee = environnement.getModele().getListeSalade().elementAt(0);
    	// AVANCER HORIZONTALEMENT
    	if (saladeSelectionee.getPositionSalade_x()>this.getPositionAnimalX()){
        	this.setPositionAnimalX(this.getPositionAnimalX()+1*facteurDeplacement);
        }
        // RECULER HORIZONTALEMENT
        if (saladeSelectionee.getPositionSalade_x()<this.getPositionAnimalX()){
    		this.setPositionAnimalX(this.getPositionAnimalX()-1*facteurDeplacement);
        }
        // AVANCER VERTICALEMENT
        if (saladeSelectionee.getPositionSalade_y()>this.getPositionAnimalY()){
    		this.setPositionAnimalY(this.getPositionAnimalY()+1*facteurDeplacement);
        }
        // RECULER VERTICALEMENT
        if (saladeSelectionee.getPositionSalade_y()<this.getPositionAnimalY()){
    		this.setPositionAnimalY(this.getPositionAnimalY()-1*facteurDeplacement);
        }
    		
    	}
    	}
    }	
     
    /**
     * Fonction permettant au escargot de manger, lorsque l'escargot se trouve à proximité d'une salade
     * il mange celle-ci se qui augmentent sa jauge de faim , son poidset diminue la valeur nutritive de la salade
     *  
     */
    
    public void mangerSalade() {
    	if (this.get_environnement().getModele().getListeEscargot().size()!=0){
    	Escargot escargotAffame = this.trouverEscargotAffame();
    	for (int i=0; i<=(this.get_environnement().getModele().getListeSalade().size())-1;i++) {
    		Salade saladeSelectionnee=get_environnement().getModele().getListeSalade().elementAt(i);
    		if (escargotAffame.getPositionAnimalX()<saladeSelectionnee.getPositionSalade_x()+10 &
    				escargotAffame.getPositionAnimalX()>saladeSelectionnee.getPositionSalade_x()-10) {	
    			if (this.etatFaim<90) {
    				saladeSelectionnee.mangerSalade(1);
    				this.setEtatFaim(this.getEtatFaim()+1);
    				this.setPoids(this.getPoids()+1);
    			}
    		}
    	}
    	}
     }
       /**
        * Permet de trouver l'escargot avec la jauge de faim le plus bas
        * @return l'index de l'escargot qui a la jauge de faim la plus basse
        */
    
    public Escargot trouverEscargotAffame() {
    	Escargot escargotAffame = null;

    	if (this.get_environnement().getModele().getListeEscargot().size()!=0) {
    		escargotAffame = this.get_environnement().getModele().getListeEscargot().elementAt(0);
        	for (int i=0; i<=(this.get_environnement().getModele().getListeEscargot().size()-1);i++) {
        		if (this.get_environnement().getModele().getListeEscargot().elementAt(i).getEtatFaim() < escargotAffame.getEtatFaim()) {
        			escargotAffame=this.get_environnement().getModele().getListeEscargot().elementAt(i);
        			
        		}
        	}
    	}
		return escargotAffame;
    }
   
    /**
     * Permet de trouver l'escargot avec le moins de points de vie
     * @return l'index de l'escargot qui a le moins de points de vie
     */
    
    public Escargot trouverEscargotFaible() {
    	Escargot escargotFaible = null;

    	if (this.get_environnement().getModele().getListeEscargot().size()!=0) {
    		escargotFaible = this.get_environnement().getModele().getListeEscargot().elementAt(0);
        	for (int i=0; i<=(this.get_environnement().getModele().getListeEscargot().size()-1);i++) {
        		if (this.get_environnement().getModele().getListeEscargot().elementAt(i).getPointsDeVie() > escargotFaible.getPointsDeVie()) {
        			escargotFaible=this.get_environnement().getModele().getListeEscargot().elementAt(i);
        			
        		}
        	}
    	}
		return escargotFaible;
    }
 	  
    
    public int getPoids() {
		return poids;
	}

	public float getEtatFaim() {
		return etatFaim;
	}  

	public void setPoids(int poids) {
		this.poids = poids;
	}


	public void setEtatFaim(int etatFaim) {
		this.etatFaim = etatFaim;
	}
	
	public void setEtatFaim(float etatFaim) {
		this.etatFaim = etatFaim;
	}
   

	public Environnement get_environnement() {
		return environnement;
	}


	public void set_environnement(Environnement _environnement) {
		this.environnement = _environnement;
	}


	public int getPointsDeVie() {
		return pointsDeVie;
	}


	public void setPointsDeVie(int pointsDeVie) {
		this.pointsDeVie = pointsDeVie;
	}

	/**
	 * Verifie si il y a des escargots
	 * @param i
	 */

	public void verifierEscargot(int i) {
			
			if (environnement.getModele().getListeEscargot().elementAt(i).getPointsDeVie()<=0){
				environnement.getModele().getListeEscargot().remove(environnement.getModele().getListeEscargot().elementAt(i));		
			}	
	}


}
